/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "ui容器部件.h"

#include "../intern/ui按钮.h"
#include "窗口/窗口.h"

#include "UI/UI.h"
#include "底层绘图/intern/Vulkan/Vulkan框架.h"

static uint32 g分割框手柄变换ID = 0;
static uint32 g分割框手柄颜色ID = 0;

static uint16 g滚动条变换绘制ID = 0;
static uint16 g滚动条颜色绘制ID = 0;



static float32	g手柄宽度 = 6;
static bool		g是否有手柄在拖动;

static vec2 手柄鼠标局部位置 = { 0,0 };








static void f_滚动框布局(C_Widget* self, C_Widget** w, uint32 num) {
	C_滚动框* 滚动框 = dynamic_cast<C_滚动框*>(self);

	vec2 size = 滚动框->m_Size;

	f_布局_双向滚动条(self, E_方向::e_纵向, 3);
	f_布局_双向滚动条(self, E_方向::e_横向, 3);
	
	if (滚动框->m_View->m_扩展视口属性) {
		滚动框->m_View->f_setSize(self->m_Size);
		//滚动框->m_View->m_扩展视口属性->m_大小 = self->m_Size;

		f_Widget_应用视口缩放(滚动框->m_View, 滚动框->m_View);

		//================ 中心偏移比例正常化 ==================
		//f_Widget_保持偏移比例(滚动框->m_View);

		//滚动框->m_View->m_绘制属性更新 = true;
	}
	else {
		if (滚动框->m_横向滚动条 && 滚动框->m_纵向滚动条) {
			滚动框->m_View->f_setSize(vec_Max(滚动框->f_getSize(), 滚动框->m_View->m_MinSize));
		}
		else {
			if (滚动框->m_横向滚动条) {
				float32 w = DEF_Max(滚动框->m_Size.x, 滚动框->m_View->m_Size.x);
				if (滚动框->m_父部件) w = DEF_Min(滚动框->m_父部件->m_Size.x, w);
				滚动框->f_setW(w);

			}
			else {
				滚动框->m_View->f_setW(滚动框->m_Size.x - 滚动框->m_滚动条厚度);
			}

			if (滚动框->m_纵向滚动条) {
				float32 h = DEF_Max(滚动框->m_Size.y, 滚动框->m_View->m_Size.y);
				//if(滚动框->m_父部件) h = DEF_Min(滚动框->m_父部件->m_Size.y, h);
				//滚动框->m_View->f_setH(h);
				//滚动框->m_View->f_setW(self->m_Size.x);
				//滚动框->m_View->f_setH(滚动框->m_Size.y);
			}
			else {
				滚动框->m_View->f_setH(滚动框->m_Size.y - 滚动框->m_滚动条厚度);
				//滚动框->f_setW(self->m_Size.x);
			}
		}
	}
}

static void f_滚动框Draw(C_Widget* self, S_2D画布* 画布) {
	C_滚动框& box = *dynamic_cast<C_滚动框*>(self);
}

static void f_set滚动框变换修改(C_Widget* self) {
	C_滚动框& box = *dynamic_cast<C_滚动框*>(self);
}

static E_事件是否传递 on_滚动视口(C_Widget* self, const S_鼠标& 鼠标) {
	C_滚动框* s = dynamic_cast<C_滚动框*>(self);

	f_Widget_应用视口滚动(self, s->m_View, E_方向::e_纵向);
	f_widget_单个部件裁剪(s->m_View, s->m_裁剪大小, s->m_GlobalLoc);

	if (s->m_横向滚动条) s->m_横向滚动条->f_从绑定部件更新滑块();
	if (s->m_纵向滚动条) s->m_纵向滚动条->f_从绑定部件更新滑块();

	self->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}


C_滚动框::C_滚动框(S_UI渲染环境& ctx, bool 横向滚动条, bool 纵向滚动条, C_Widget* view) : C_Widget(&ctx) {
	mf_布局 = f_滚动框布局;
	//mf_绘制 = f_滚动框Draw;
	//mf_变换 = f_set滚动框变换修改;
	mf_鼠标滚轮 = on_滚动视口;

	
	if (view) {
		m_View = view;
	}
	else {
		m_View = new C_Widget(&ctx);
		m_View->f_setSize(f_getSize());
	}
	f_添加子组件(m_View);


	m_滚动条厚度 = 10;
	if (横向滚动条 && 纵向滚动条) {
		m_双向滚动条 = new S_双向滚动条(m_滚动条厚度, this, ctx);

		//m_双向滚动条->m_H->f_映射值指针(&m_View->m_Pos.x);
		//m_双向滚动条->m_V->f_映射值指针(&m_View->m_Pos.y);

		m_双向滚动条->m_H->f_set值范围({ 0, m_View->m_Size.x });
		m_双向滚动条->m_V->f_set值范围({ 0, m_View->m_Size.y });
	}

	if (横向滚动条) {
		m_横向滚动条 = new C_滚动条(ctx, E_方向::e_横向);
		//m_横向滚动条->f_映射值指针(&m_View->m_Pos.x);
		m_横向滚动条->f_set值范围({ 0, m_View->m_Size.x });
		f_添加子组件(m_横向滚动条);
	}
	else {
		m_横向滚动条 = nullptr;
	}
	if (纵向滚动条) {
		m_纵向滚动条 = new C_滚动条(ctx, E_方向::e_纵向);
		//m_纵向滚动条->f_映射值指针(&m_View->m_Pos.y);
		m_纵向滚动条->f_set值范围({ 0, m_View->m_Size.y });
		f_添加子组件(m_纵向滚动条);
	}
	else {
		m_纵向滚动条 = nullptr;
	}

	m_颜色A = S_UI主题::uic_深色;
}

C_滚动框::~C_滚动框() {
	
}

C_Widget* f_ui_创建滚动框(S_UI渲染环境& ctx, bool 横向滚动条, bool 纵向滚动条, C_Widget* view) {
	C_Widget* w = new C_滚动框(ctx, 横向滚动条, 纵向滚动条, view);
	return w;
}

void f_ui_滚动框安装视口组件(C_Widget* 滚动框, C_Widget* view) {
	C_滚动框* box = dynamic_cast<C_滚动框*>(滚动框);
	box->m_子组件[0] = view;
	box->m_View = view;

	view->m_父部件 = box;
	view->m_更新绘制属性 = true;
}






void f_ui_拖拽手柄激活鼠标样式(C_Widget* self) {
	C_分割框手柄* 手柄 = dynamic_cast<C_分割框手柄*>(self);

	if (手柄->m_方向 == E_方向::e_横向) {
		C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_纵向双箭头;
	}
	else {
		C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_横向双箭头;
	}

	self->m_拖放阻止鼠标进出事件 = true;
}

void f_ui_拖拽手柄关闭鼠标样式(C_Widget* self) {
	C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_默认;
	self->m_拖放阻止鼠标进出事件 = false;
	f_window_set鼠标样式(C_Widget::g_鼠标样式);
}

E_事件是否传递 f_分割框手柄准备拖动(C_Widget* self, const S_鼠标& 鼠标, S_拖放数据& data) {
	C_分割框手柄* 手柄 = dynamic_cast<C_分割框手柄*>(self);
	//auto* 分割框 = dynamic_cast<C_分割框*>(手柄->m_父部件);
	data.m_Type = E_拖放数据类型::e_鼠标拖放_滚动条;
	data.m_Next = self;

	手柄鼠标局部位置 = f_widget_get鼠标局部位置(鼠标.gPos, self);
	
	f_ui_拖拽手柄激活鼠标样式(手柄);
	
	data.m_Type = E_拖放数据类型::e_鼠标拖放_分割条;
	data.m_Next = 手柄;
	g是否有手柄在拖动 = true;
	return E_事件是否传递::e_事件传递_继续;
}

E_事件是否传递 f_分割框手柄拖动(struct C_Widget* 部件, const S_鼠标& 鼠标, S_拖放数据& data) {
	if(data.m_Type != E_拖放数据类型::e_鼠标拖放_分割条) return E_事件是否传递::e_事件传递_继续;

	C_分割框手柄& 手柄 = *dynamic_cast<C_分割框手柄*>(部件);
	

	float32 手柄宽度 = g手柄宽度 * 部件->m_UIctx->m_DPI;
	//std::cout << value.x << " " << value.y << std::endl;
	vec2 pos = f_widget_get鼠标局部位置(鼠标.gPos, 手柄.m_父部件);
	//std::cout << pos.x << pos.y << std::endl;
	switch (手柄.m_父部件->m_Type) {
		case E_WidgetType::t_分割框: {
			auto* 分割框 = dynamic_cast<C_分割框*>(手柄.m_父部件);

			switch (手柄.m_方向) {
				case E_方向::e_横向:
					分割框->f_分割条移动(pos.y - 手柄鼠标局部位置.y + 手柄宽度 * 0.5, 手柄.m_分割条ID);
					break;
				case E_方向::e_纵向:
					分割框->f_分割条移动(pos.x - 手柄鼠标局部位置.x + 手柄宽度 * 0.5, 手柄.m_分割条ID);
					break;
			}
			break;
		}
	}
	
	return E_事件是否传递::e_事件传递_终止;
}

bool on_分割框手柄结束拖放(C_Widget* self, C_Widget* 拾取的部件, S_拖放数据& data) {
	
	if (data.m_Type == E_拖放数据类型::e_鼠标拖放_分割条) {
		g是否有手柄在拖动 = false;

		C_分割框手柄& 手柄 = *(C_分割框手柄*)(data.m_Next);

		switch (手柄.m_父部件->m_Type) {
			case E_WidgetType::t_分割框: {
				auto& box = *dynamic_cast<C_分割框*>(手柄.m_父部件);
				switch (box.m_排列方向) {
					case E_方向::e_横向: {
						手柄.m_分割手柄偏移 = 0.5;
						break;
					}
					case E_方向::e_纵向: {
						手柄.m_分割手柄偏移 = 0.5;
						break;
					}
				}
				break;
			}
		}

		self->m_ColorA.m_颜色 = S_UI主题::uic_拖拽手柄;
		self->m_父部件->m_更新绘制属性 = true;
		
		f_ui_拖拽手柄关闭鼠标样式(self);
	}
	return true;
}



static E_事件是否传递 on_分割框手柄鼠标进入(C_Widget* self, const S_鼠标& 轮值) {
	C_分割框手柄& 手柄 = *static_cast<C_分割框手柄*>(self);

	auto 鼠标位置 = f_widget_get鼠标位置(self);

	if (手柄.m_方向 == E_方向::e_横向) {
		C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_纵向双箭头;
		手柄.m_分割手柄偏移 = 鼠标位置.x / self->m_Size.x;
	}
	else {
		C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_横向双箭头;
		手柄.m_分割手柄偏移 = 鼠标位置.y / self->m_Size.y;
	}
	f_widget_更新渲染层(self->m_父部件);


	self->m_ColorA.m_颜色 = S_UI主题::uic_拖拽手柄 + 50;
	self->m_父部件->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 on_分割框手柄鼠标移出(C_Widget* self, const S_鼠标& 轮值) {
	if (!g是否有手柄在拖动) {
		
	}
	if (!self->m_拖放阻止鼠标进出事件) {
		C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_默认;

		self->m_ColorA.m_颜色 = S_UI主题::uic_拖拽手柄;
		self->m_更新绘制属性 = true;
	}
	self->m_父部件->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}

C_分割框手柄::C_分割框手柄(S_UI渲染环境& ctx, E_方向 方向) : C_Widget(&ctx) {
	m_TypeName = "分割框手柄";
	m_Type = E_WidgetType::t_分割手柄;
	f_setSize(vec2{4});
	m_分割条ID = 0;
	m_方向 = 方向;

	mf_开始拖拽	= f_分割框手柄准备拖动;
	mf_拖拽		= f_分割框手柄拖动;
	mf_结束拖拽	= on_分割框手柄结束拖放;


	mf_鼠标进入 = on_分割框手柄鼠标进入;
	mf_鼠标离开 = on_分割框手柄鼠标移出;
	m_分割手柄偏移 = 0.5;
	m_ColorA.m_颜色 = S_UI主题::uic_拖拽手柄;
}

C_Widget* f_ui_创建拖拽手柄(S_UI渲染环境& ctx, E_方向 方向) {
	C_分割框手柄* box = new C_分割框手柄(ctx, 方向);
	box->m_方向 = 方向;
	return box;
}




static void f_分割框布局(C_Widget* self, C_Widget** w, uint32 num) {
	auto* 分割框 = dynamic_cast<C_分割框*>(self);

	uint32 手柄数量 = self->m_子组件.size();
	if (手柄数量 == 0) return;

	手柄数量 /= 2;

	float32 手柄宽度 = S_UI主题::ui_拖拽手柄宽度 * self->m_UIctx->m_DPI;
	float32 除去手柄大小 = 手柄宽度 * 手柄数量;

	auto* 分割比例	= 分割框->m_分割比例.data();
	

	switch (分割框->m_排列方向) {
		case E_方向::e_横向: {
			float32 h = self->m_Size.y;
			vec2 pos = { 0.0, 0.0 };
			vec2 size;

			for (uint16 i = 0; i < num; ++i) {
				
				if (i & 1) {
					size = { self->m_Size.x, 手柄宽度 };
				}
				else {
					size = { self->m_Size.x, h * 分割比例[i>>1]};
					size.y -= pos.y;
					size.y -= i+1 >= num ? 0 : 手柄宽度 * 0.5f;
				}
				
				w[i]->f_setPos(pos);
				w[i]->f_setSize(size);

				pos.y += size.y;
			}
			break;
		}

		case E_方向::e_纵向: {
			float32 width = self->m_Size.x;
			vec2 pos = { 0.0, 0.0 };

			for (uint16 i = 0; i < num; ++i) {
				vec2 size;

				if (i & 1) {
					size = { 手柄宽度, self->m_Size.y };
				}
				else {
					size = { width * 分割比例[i>>1], self->m_Size.y };
					size.x -= pos.x;
					size.x -= i+1 >= num ? 0 : 手柄宽度 * 0.5f;
				}

				w[i]->f_setPos(pos);
				w[i]->f_setSize(size);

				pos.x += size.x;
			}
			break;
		}
	}

}

static void f_分割框绘制(struct C_Widget* self, struct S_2D画布* 画布) {
	auto& box = *dynamic_cast<C_分割框*>(self);
	box.m_背景 = f_vg_genConvex((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal);
}

static void f_分割框变换(C_Widget* self) {
	auto& box = *dynamic_cast<C_分割框*>(self);
	//auto* rf = f_vk_get绘图框架((*self));
	auto e = self->f_get更新组件();
	
	std::vector<S_2DConvexRect> 区间;
	std::vector<S_GPU内存块*>	形状;
	std::vector<S_2D颜色包>		颜色;
	std::vector<vec2>			位置;

	区间.reserve(e.m_Num);
	形状.reserve(e.m_Num);
	颜色.reserve(e.m_Num);
	位置.reserve(e.m_Num);
	
	for (uint16 i = 0; i < e.m_Num; ++i) {
		if (i & 1) {
			bool 手柄展开 = e.m_W[i]->m_ColorA.m_颜色.a != S_UI主题::uic_拖拽手柄.a;
			f_ui_draw_temple_拖放条手柄(e.m_W[i], 区间, 形状, 颜色, 位置, e.m_W[i]->m_拖放阻止鼠标进出事件);
		}
		else {

		}
		
		//S_2DConvexRect rect{};
		//vec2 pos = e.m_W[i]->m_Pos;
		//vec2 size = e.m_W[i]->m_Size;
		//
		//rect.AA_type = {1,0};
		//rect.radius = { S_UI主题::ui_面板圆角半径, S_UI主题::ui_面板圆角半径 };
		//rect.size = size;
		//
		//区间.emplace_back(rect);
		//位置.emplace_back(pos);
		//颜色.emplace_back(S_RGBA8UI{10,10,10,255});
		//形状.emplace_back(&((*self).m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形));
		//
		//if (i & 1) {
		//	box.m_排列方向 == E_方向::e_横向 ? size.x *= 0.98 : size.y *= 0.98;
		//
		//	C_分割框手柄& 手柄 = *static_cast<C_分割框手柄*>(e.m_W[i]);
		//	
		//	if (box.m_排列方向 == E_方向::e_横向) {
		//		pos.x = (e.m_W[i]->m_Size.x - size.x)*0.5f;
		//		pos.y += size.y * 0.3;
		//
		//		size.y *= 0.3;
		//	}
		//	else {
		//		pos.x += size.x * 0.3;
		//		pos.y = (e.m_W[i]->m_Size.y - size.y)*0.5f;
		//
		//		size.x *= 0.3;
		//	}
		//
		//	rect.size = size;
		//	颜色.emplace_back(S_UI主题::uic_深色 + 10);
		//	区间.emplace_back(rect);
		//	位置.emplace_back(pos);
		//	形状.emplace_back(&((*self).m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形));
		//
		//
		//	if (box.m_排列方向 == E_方向::e_横向) {
		//		size.x *= 0.2;
		//		pos.x = 手柄.m_分割手柄偏移 * e.m_W[i]->m_Size.x - size.x*0.5f;
		//	}
		//	else {
		//		size.y *= 0.2;
		//		pos.y = 手柄.m_分割手柄偏移 * e.m_W[i]->m_Size.y - size.y*0.5f;
		//	}
		//
		//	rect.size = size;
		//	颜色.emplace_back(S_UI主题::uic_深色 + 20);
		//	区间.emplace_back(rect);
		//	位置.emplace_back(pos);
		//	形状.emplace_back(&((*self).m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形));
		//}
	}

	f_vg_tranform(*box.m_背景, 位置.size(), 位置.data());
	f_vg_drawConvex(*box.m_背景, 区间.size(), 形状.data(), 区间.data());
	f_vg_color(*box.m_背景, 颜色.size(), 颜色.data());
}



// : C_Widget(&ctx)
C_分割框::C_分割框(S_UI渲染环境& ctx, E_方向 方向): C_Widget(&ctx), m_排列方向(方向) {
	m_Type = E_WidgetType::t_分割框;
	f_widget_添加绘制画布(this);
	m_TypeName	= "分割框";
	m_WName		= u"分割框";

	mf_布局 = f_分割框布局;
	mf_绘制 = f_分割框绘制;
	mf_变换 = f_分割框变换;
}

C_分割框::~C_分割框() {
}

void C_分割框::f_add分割(C_Widget* w, float32 比例) {
	if (m_子组件.size()) {
		C_分割框手柄* 手柄 = new C_分割框手柄(*m_UIctx, m_排列方向);
		手柄->m_分割条ID = m_子组件.size() / 2;
		//手柄->mf_鼠标进入 = on_分割框手柄鼠标进入;
		//手柄->mf_鼠标离开 = on_分割框手柄鼠标移出;
		f_添加子组件(手柄);
	}
	f_添加子组件(w);
	m_分割比例.push_back(比例);
}

void C_分割框::f_remove分割(int8 dir) {
}

void C_分割框::f_分割条移动(float32 局部位置, int16 分割条ID) {
	C_分割框手柄* 手柄 = dynamic_cast<C_分割框手柄*>(m_子组件[分割条ID * 2 + 1]);

	vec2 pos = {};
	vec2 size = m_Size;

	float32 手柄宽度 = g手柄宽度 * m_UIctx->m_DPI;

	if (局部位置 < 手柄宽度) 局部位置 = 手柄宽度;
	//float32 原比例 = m_分割比例[手柄->m_分割条ID];
	switch (m_排列方向) {
		case E_方向::e_横向: {
			float32 w = 局部位置 / m_Size.y;
			if(手柄->m_分割条ID && w < m_分割比例[手柄->m_分割条ID - 1]) w = clamp(w, m_分割比例[手柄->m_分割条ID - 1], 1);
			m_分割比例[手柄->m_分割条ID] = w;
			//m_分割比例[手柄->m_分割条ID + 1] += m_分割比例[手柄->m_分割条ID] - 原比例;
			
			pos = { 0.0f, m_分割比例[手柄->m_分割条ID] * m_Size.y - 手柄宽度 * 0.5f };
			手柄->f_setPos(pos);
			
			//控制柄前一个部件
			if (手柄->m_分割条ID) {
				size.y = (m_分割比例[手柄->m_分割条ID] * m_Size.y) - 手柄宽度 * 0.5f;
			}
			else {
				size.y = pos.y; 
				pos.y = 0;
			}
			m_子组件[2 * 手柄->m_分割条ID]->f_setSize(size);


			//控制柄后一个部件
			pos.y = m_分割比例[手柄->m_分割条ID] * m_Size.y + 手柄宽度 * 0.5f;
			size.y = (m_分割比例[手柄->m_分割条ID + 1] - m_分割比例[手柄->m_分割条ID]) * m_Size.y;

			m_子组件[2 * 手柄->m_分割条ID + 2]->f_setPos(pos);
			m_子组件[2 * 手柄->m_分割条ID + 2]->f_setSize(size);
			break;
		}
		
		case E_方向::e_纵向: {
			float32 w = 局部位置 / m_Size.y;
			if(手柄->m_分割条ID && w < m_分割比例[手柄->m_分割条ID - 1]) w = clamp(w, m_分割比例[手柄->m_分割条ID - 1], 1);
			m_分割比例[手柄->m_分割条ID] = 局部位置 / m_Size.x;

			pos = { m_分割比例[手柄->m_分割条ID] * m_Size.x - 手柄宽度 * 0.5f, 0.0f };
			//if (pos.x < 手柄宽度) pos.x = 手柄宽度;
			手柄->f_setPos(pos);

			if (手柄->m_分割条ID) {
				size.x = (m_分割比例[手柄->m_分割条ID] - m_分割比例[手柄->m_分割条ID - 1]) * m_Size.x - 手柄宽度;
			}
			else {
				size.x = pos.x;
				pos.x = 0;
			}

			m_子组件[2 * 手柄->m_分割条ID]->f_setSize(size);



			pos.x = m_分割比例[手柄->m_分割条ID] * m_Size.x + 手柄宽度 * 0.5;
			size.x = (m_分割比例[手柄->m_分割条ID + 1] - m_分割比例[手柄->m_分割条ID]) * m_Size.x - 手柄宽度;

			m_子组件[2 * 手柄->m_分割条ID + 2]->f_setPos(pos);
			m_子组件[2 * 手柄->m_分割条ID + 2]->f_setSize(size);
			break;
		}
	}

	//f_widget_更新绘制(this);
	//m_分割比例[手柄->m_分割条ID] = 局部位置 / m_Size.x;
	m_更新绘制属性 = true;

}

std::vector<C_Widget*>	f_ui_get分割框页面组件(C_Widget* self) {
	std::vector<C_Widget*> ws;

	auto e = self->f_get更新组件();
	uint32 num = e.m_Num;
	for (uint32 i = 0; i < num; ++i) {
		if(!(i&0x00000001)) ws.emplace_back(e.m_W[i]);
	}

	return ws;
}








static E_事件是否传递 on_标签关闭按钮鼠标进入(C_Widget* self, const S_鼠标& 轮值) {
	C_多页面* mpag = dynamic_cast<C_多页面*>(self->m_父部件->m_父部件);
	self->m_ColorA = S_UI主题::uic_单色图标 - S_RGBA8UI{0,120,120,0};
	mpag->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 on_标签关闭按钮鼠标移出(C_Widget* self, const S_鼠标& 轮值) {
	C_多页面* mpag = dynamic_cast<C_多页面*>(self->m_父部件->m_父部件);
	self->m_ColorA = S_UI主题::uic_单色图标 - S_RGBA8UI{80,80,80,0};
	mpag->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}

static void on_多页面布局(C_Widget* self, C_Widget** w, uint32 num) {
	if (!num) return;

	C_多页面& box = *dynamic_cast<C_多页面*>(self);
	
	float32 dpi = self->m_UIctx->m_DPI;
	vec2 pos = vec2{4, 4} * dpi;
	vec2 size = box.m_Size;
	
	if (box.m_排列方向 == E_方向::e_纵向) {
		for (uint32 i = 1; i < num; ++i) {
			w[i]->f_setPos(pos);

			pos.y += box.m_头大小.y * dpi + 4;
		}

		pos = { box.m_头大小.x * dpi, 0 };
		size.x -= box.m_头大小.x * dpi;
		
		w[0]->f_setPos(pos);
		w[0]->f_setSize(size);
	}
	else {
		
		if (box.m_可关闭) {
			--num;
			w[num]->f_setPos({ (box.m_头大小.x * dpi + (4 * dpi * 2)) * (num - 1), 4 * dpi });
			w[num]->f_setSize(_Vec2(box.m_头大小.y * dpi));
		}
		
		for (uint32 i = 1; i < num; ++i) {
			w[i]->f_setPos(pos);
			w[i]->f_setSize(box.m_头大小 * dpi);

			if (box.m_可关闭 && w[i]->m_子组件.size()) {
				vec2 关闭按钮大小 = w[i]->m_Size;
				关闭按钮大小.x = DEF_Min(关闭按钮大小.x, 关闭按钮大小.y);
				关闭按钮大小.x = 关闭按钮大小.y;
				w[i]->m_子组件[0]->f_setPos({1,1});
				w[i]->m_子组件[0]->f_setSize(关闭按钮大小 - 2 * dpi);
			}

			pos.x += box.m_头大小.x * dpi + 4 * dpi;
		}

		

		pos = { 0, box.m_头大小.y * dpi };
		size.y -= box.m_头大小.y * dpi;
		
		w[0]->f_setPos(pos);
		w[0]->f_setSize(size);
	}
}

static void on_多页面绘制(C_Widget* self, S_2D画布* 画布) {
	C_多页面& box = *dynamic_cast<C_多页面*>(self);

	box.m_背景 = f_vg_genConvex(self->m_UIctx->m_Ctx, *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal);
	box.m_标签 = f_vg_genString((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal, u"雅黑");
	box.m_图标 = f_vg_genIco((*self), *画布, E_图层混合模式::e_Normal, E_填充模式::e_填充面);
}

static void on_多页面变换(C_Widget* self) {
	C_多页面& box = *dynamic_cast<C_多页面*>(self);
	uint32 标签数量 = box.m_分页面.size();
	float32 dpi = self->m_UIctx->m_DPI;

	auto e = box.f_get更新组件();
	uint32 num = 标签数量;


	std::vector<S_Rect2Df>		标签区域(标签数量);
	std::vector<std::u16string>	标签文本(标签数量);
	std::vector<S_RGBA8UI>		标签颜色(标签数量);


	if (box.m_添加按钮) {
		num += 2;
	}
	else {
		num += 1;
	}

	std::vector<S_2DConvexRect>	背景区域(1);
	std::vector<S_GPU内存块*>	背景形状(1);
	std::vector<S_RGBA8UI>		背景颜色(1);
	std::vector<vec2>			背景位置(1);

	std::vector<std::u16string> 图标名称;
	std::vector<S_2D颜色包>		图标颜色;
	std::vector<vec2>			图标位置;
	std::vector<vec2>			图标大小;


	S_2DConvexRect rect;

	rect.offset = {};
	rect.size = { self->m_Size.x, box.m_头大小.y * dpi };
	rect.radius = { S_UI主题::ui_面板圆角半径, S_UI主题::ui_面板圆角半径 };
	rect.AA_type = { f_PackData4X8(S_UI主题::uic_页面标签背景), 0 };

	背景区域[0] = rect;
	背景形状[0] = &((*self).m_UIctx->m_Ctx.m_几何图形->m_平面上圆角矩形);
	背景颜色[0] = S_UI主题::uic_页面标签背景;
	背景位置[0] = {};

	

	uint32 index = 0;
	for (uint32 i = 1; i <= 标签数量; ++i) {
		rect.size = e.m_W[i]->m_Size * vec2{ 1, 0.8f };
		float32 icoSize = rect.size.y;

		if (box.m_排列方向 == E_方向::e_纵向) {
			背景形状.push_back(&((*self).m_UIctx->m_Ctx.m_几何图形->m_平面右圆角矩形));
		}
		else {
			背景形状.push_back(&((*self).m_UIctx->m_Ctx.m_几何图形->m_平面上圆角矩形));
		}
		背景位置.push_back(e.m_W[i]->m_Pos);
		背景区域.push_back(rect);

		背景颜色.push_back(e.m_W[i]->m_颜色A);


		标签文本[index] = e.m_W[i]->m_WName;
		标签区域[index] = { e.m_W[i]->m_Pos, rect.size };
		标签颜色[index] = S_UI主题::uic_标签文字颜色;

		if (box.m_可关闭) {
			auto but = e.m_W[i]->f_get子组件(0);

			图标名称.push_back(u"删除");
			图标颜色.push_back(but->m_ColorA);
			图标位置.push_back(vec2{icoSize, icoSize} * 0.5 + e.m_W[i]->m_Pos);
			图标大小.push_back(vec2{icoSize, icoSize} * 0.5);

			rect.size = vec2{icoSize,icoSize} * 0.7;
			背景形状.push_back(&((*self).m_UIctx->m_Ctx.m_几何图形->m_平面圆形));
			背景位置.push_back(e.m_W[i]->m_Pos + vec2{icoSize,icoSize} * 0.15);
			背景区域.push_back(rect);
			背景颜色.push_back(but->m_ColorA.m_颜色 - S_RGBA8UI{80,80,80,0});
		}

		++index;
	}

	if (box.m_添加按钮) {
		rect.size	= box.m_添加按钮->m_Size * vec2{ 1, 0.8f };

		背景位置.push_back(box.m_添加按钮->m_Pos);
		背景形状.push_back(&((*self).m_UIctx->m_Ctx.m_几何图形->m_平面上圆角矩形));
		背景区域.push_back(rect);
		背景颜色.push_back(box.m_添加按钮->m_颜色A);


		图标名称.push_back(u"加");
		图标颜色.push_back(S_UI主题::uic_图标颜色);
		图标位置.push_back(rect.size * 0.5 + box.m_添加按钮->m_Pos);
		图标大小.push_back(box.m_添加按钮->m_Size * 0.5);
	}

	f_vg_tranform(*box.m_背景, 背景位置.size(), 背景位置.data());
	f_vg_drawConvex(*box.m_背景, 背景形状.size(), 背景形状.data(), 背景区域.data());
	f_vg_color(*box.m_背景, 背景颜色.size(), 背景颜色.data());

	S_行字符串绘制属性 行字符串绘制属性 = { S_UI主题::ui_文字间隔 * dpi, E_方向::e_横向 };
	f_vg_drawString(*box.m_标签, 标签文本, 标签区域, 标签颜色, E_对齐方式::e_据中对齐, 行字符串绘制属性);

	f_vg_drawIco(*box.m_图标, 图标名称.size(), 图标名称.data());
	f_vg_tranform(*box.m_图标, 图标位置.size(), 图标位置.data(), 图标大小.data());
	f_vg_color(*box.m_图标, 图标颜色.size(), 图标颜色.data());

	return;
}

static E_事件是否传递 on_标签鼠标进入(C_Widget* self, const S_鼠标& 轮值) {
	C_多页面* mpag = dynamic_cast<C_多页面*>(self->m_父部件);

	uint32 loc = f_widget_取组件位置索引(mpag, self);
	if (mpag->m_当前页面ID == loc - 1) {
		self->m_颜色A = self->m_颜色C;
	}
	else {
		self->m_颜色A = self->m_颜色B + S_RGBA8UI{30, 30, 30, 0};
	}
	mpag->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 on_标签鼠标移出(C_Widget* self, const S_鼠标& 轮值) {
	C_多页面* mpag = dynamic_cast<C_多页面*>(self->m_父部件);

	uint32 loc = f_widget_取组件位置索引(mpag, self);
	if (mpag->m_当前页面ID == loc - 1) {
		self->m_颜色A = self->m_颜色C;
	}
	else {
		self->m_颜色A = self->m_颜色B;
	}
	mpag->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 f_多页面标签选中(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_多页面* mpag = dynamic_cast<C_多页面*>(self->m_父部件);
	uint32 loc = f_widget_取组件位置索引(mpag, self);
	mpag->f_set页面(loc - 1);

	int32 num = mpag->m_子组件.size() - 1;
	for (int32 i=1; i<num; ++i) {
		mpag->m_子组件[i]->m_颜色A = self->m_颜色B;
	}
	self->m_颜色A = self->m_颜色C;

	mpag->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 f_标签关闭页面(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_多页面* mpag = dynamic_cast<C_多页面*>(self->m_父部件->m_父部件);

	if (mpag->m_分页面.size() > 1) {
		int32 loc = f_widget_取组件位置索引(mpag, self->m_父部件);

		if (loc >= 2) {
			--loc;
			mpag->f_del页面(loc);

			if (mpag->m_当前页面ID == loc) {
				--mpag->m_当前页面ID;

				int32 num = mpag->m_子组件.size() - 1;
				for (int32 i=1; i<num; ++i) {
					mpag->m_子组件[i]->m_颜色A = self->m_颜色B;
				}

				mpag->m_子组件[mpag->m_当前页面ID]->m_颜色A = self->m_颜色C;
			}
		}
	}

	
	
	return E_事件是否传递::e_事件传递_终止;
}

C_多页面::C_多页面(S_UI渲染环境& ctx, E_方向 方向, const vec2 标签头大小) : C_Widget(&ctx), m_排列方向(方向) {
	m_WName = u"多页面";
	m_TypeName = "C_Widget 多页面";

	mf_布局 = on_多页面布局;
	mf_绘制 = on_多页面绘制;
	mf_变换 = on_多页面变换;

	m_头大小 = 标签头大小;
	m_是否延展 = { true, true };
	
	m_页面数量 = 1;
	m_当前页面ID = 0;
	
	m_关闭按钮颜色 = S_UI主题::uic_单色图标;
	m_关闭按钮颜色 -= {100,100,100,0};

	m_添加按钮 = nullptr;
	m_可关闭 = true;
	

	f_widget_添加绘制画布(this);
}

C_多页面::~C_多页面() {
}

void C_多页面::f_add页面(C_Widget* w, int32 loc) {
	
	f_add页面(w->m_WName, loc);

	w->m_更新绘制属性 = true;
	w->m_被裁剪 = true;
	w->m_显示 = false;
	
	if (!m_分页面.size()) {
		f_添加子组件(w, 0);
		loc = m_当前页面ID;
	}
	m_分页面.push_back(w);

	if (loc != m_当前页面ID) {
		w->f_置显示(false);
	}
}

void C_多页面::f_add页面(std::u16string name, int32 loc) {
	auto e = f_get更新组件();
	uint32 子部件数量 = f_get子部件数量();

	if (loc >= 子部件数量) {
		float32 dpi = m_UIctx->m_DPI;

		C_Widget* 标签 = new C_Widget(m_UIctx);
		标签->mf_鼠标点击 = f_多页面标签选中;
		标签->m_实例ID = m_分页面.size();
		标签->f_setSize(m_头大小 * dpi);

		标签->mf_鼠标进入 = on_标签鼠标进入;
		标签->mf_鼠标离开 = on_标签鼠标移出;
		标签->m_颜色A = S_UI主题::uic_页面标签;
		标签->m_颜色B = S_UI主题::uic_页面标签;
		标签->m_颜色C = S_UI主题::uic_页面焦点标签;
		标签->m_ICO = u"删除";
		标签->m_WName = name;

		

		if (m_可关闭) {
			C_Widget* 关闭按钮 = new C_Widget(m_UIctx);
			关闭按钮->f_setSize({ 20,20 });
			关闭按钮->m_ICO = u"删除";
			关闭按钮->m_ColorA = S_UI主题::uic_单色图标 - S_RGBA8UI{80,80,80,0};
			关闭按钮->mf_鼠标点击 = f_标签关闭页面;

			关闭按钮->mf_鼠标进入 = on_标签关闭按钮鼠标进入;
			关闭按钮->mf_鼠标离开 = on_标签关闭按钮鼠标移出;
			标签->f_添加子组件(关闭按钮);
		}

		if (m_添加按钮) {
			loc = 子部件数量 - 1;
		}
		else {
			loc = 子部件数量;
		}
		if (loc == m_当前页面ID) {
			标签->m_颜色A = S_UI主题::uic_页面焦点标签;
		}
		f_添加子组件(标签, loc);
	}
	else {
		e.m_W[loc + 1]->m_WName = name;
	}
}

C_Widget* C_多页面::f_del页面(int8 loc) {
	C_Widget* delWidget = m_分页面[loc];
	
	delWidget->m_显示 = false;
	delWidget->m_颜色A = delWidget->m_颜色B;
	if (delWidget->mf_打开关闭) delWidget->mf_打开关闭(delWidget, false);

	m_分页面.erase(m_分页面.begin() + loc);
	f_widget_remove区间子组件(this, loc + 1, loc + 2, false);
	
	loc = DEF_Max(0, loc - 1);
	f_set页面(loc);

	return delWidget;
}

void C_多页面::f_set页面(uint32 id) {
	if(id >= m_分页面.size() || m_当前页面ID == id) return;
	
	if (m_当前页面ID < m_分页面.size()) {
		m_分页面[m_当前页面ID]->m_显示 = false;
		//m_分页面[m_当前页面ID]->m_颜色A = m_分页面[m_当前页面ID]->m_颜色B;
		m_子组件[m_当前页面ID+1]->m_颜色A = m_子组件[m_当前页面ID+1]->m_颜色B;
		
		if (m_分页面[m_当前页面ID]->mf_打开关闭) m_分页面[m_当前页面ID]->mf_打开关闭(m_分页面[m_当前页面ID], false);

		m_分页面[m_当前页面ID]->f_置显示(false);
	}
	m_当前页面ID = id;



	auto& e = m_分页面[m_当前页面ID];
	if (m_分页面.size()) {
		m_子组件[0]->m_被裁剪 = false;
	}
	if (e->mf_打开关闭) e->mf_打开关闭(e, true);
	e->m_更新绘制属性 = true;

	e->m_被裁剪 = false;
	f_替换子组件(0, e);

	m_分页面[m_当前页面ID]->f_置显示(true);
	m_子组件[m_当前页面ID + 1]->m_颜色A = m_子组件[m_当前页面ID + 1]->m_颜色C;

	f_widget_重构渲染层(m_分页面[m_当前页面ID]);
}


C_Widget* f_ui_创建多页面(S_UI渲染环境& ctx, E_方向 标签方向, const std::vector<C_Widget*>& ws, const vec2 标签头大小, bool 可关闭) {
	auto 多页面 = new C_多页面(ctx, 标签方向);

	多页面->m_可关闭 = 可关闭;
	多页面->m_头大小 = 标签头大小;
	for (auto& e : ws) 多页面->f_add页面(e, -1);

	return 多页面;
}

C_Widget* f_ui_创建多页面(S_UI渲染环境& ctx, E_方向 标签方向, const std::vector<std::u16string>& ws, const vec2 标签头大小) {
	auto 多页面 = new C_多页面(ctx, 标签方向);

	多页面->m_头大小 = 标签头大小;
	for (auto& e : ws) {
		多页面->f_add页面(e, -1);
	}
	return 多页面;
}

E_方向 f_ui_get多页面标签方向(C_Widget* self) {
	return static_cast<C_多页面*>(self)->m_排列方向;
}

std::vector<C_Widget*> f_ui_get多页面所有页面(C_Widget* self) {
	return static_cast<C_多页面*>(self)->m_分页面;
}

C_Widget* f_ui_get选项夹页面(C_Widget* w, uint16 id) {
	auto* page = dynamic_cast<C_多页面*>(w);
	if (page && id < page->m_分页面.size()) {
		return page->m_分页面[id];
	}
	return 0;
}

void f_ui_选项夹是否可关闭(C_Widget* self, bool 可关闭) {
	C_多页面* 选项夹 = static_cast<C_多页面*>(self);

	if (可关闭) {
		
	}
}

void f_ui_set多页面添加事件(C_Widget* self, fp_Widget鼠标按键 切换回调, vec2 size) {
	C_多页面* mpage = static_cast<C_多页面*>(self);

	//mpage->m_添加按钮 = (C_按钮*)f_ui_创建按钮(nullptr, 0);
	mpage->m_添加按钮 = new C_按钮(mpage->m_UIctx);
	mpage->m_添加按钮->m_实例ID = 0xffffffff;
	mpage->m_添加按钮->f_setSize(size);
	mpage->m_添加按钮->mf_鼠标点击 = 切换回调;
	mpage->m_添加按钮->m_ICO = u"加";

	mpage->f_添加子组件(mpage->m_添加按钮, -1);
}

void f_ui_set多页面当前页面(C_Widget* self, uint32 id) {
	assert(dynamic_cast<C_多页面*>(self));
	static_cast<C_多页面*>(self)->f_set页面(DEF_Min(id, static_cast<C_多页面*>(self)->m_分页面.size() - 1));
	//static_cast<C_多页面*>(self)->m_当前页面ID = DEF_Min(id, static_cast<C_多页面*>(self)->m_分页面.size());
}

uint32 f_ui_get多页面页数量(C_Widget* self) {
	C_多页面* 选项夹 = static_cast<C_多页面*>(self);
	return 选项夹->m_分页面.size();
}

uint32 f_ui_get多页面页ID(C_Widget* self) {
	C_多页面* 选项夹 = static_cast<C_多页面*>(self);
	return 选项夹->m_当前页面ID;
}

void f_ui_多页面可关闭(C_Widget* self, bool 可关闭) {
	C_多页面* 选项夹 = static_cast<C_多页面*>(self);
	选项夹->m_可关闭 = 可关闭;
}







static void on_展开栏布局(C_Widget* self, C_Widget** w, uint32 num) {
	float32 g2 = self->m_间隔宽度;

	//w[0]->f_setW(self->m_Size.x);
	w[0]->f_setPos({ g2, g2 });

	w[1]->f_setPos({ w[0]->m_Size.x + g2, g2 });
	w[1]->f_setW(self->m_Size.x - (w[0]->m_Size.x + g2*2));
	
	if (num >= 3) {
		w[2]->f_setPos({ g2, w[0]->m_Size.y + g2*2 });
		g2 = self->m_间隔宽度 * 2;
		w[2]->f_setSize({ self->m_Size.x - g2, self->m_Size.y - (w[1]->m_Size.y + g2) });
	}
}

C_展开栏::C_展开栏(S_UI渲染环境& ctx, C_Widget* 内部组件) : C_Widget(&ctx) {
	//assert(内部组件);

	C_Widget*		展开按钮 = new C_Widget(&ctx);
	C_分割框手柄*	拖动按钮 = new C_分割框手柄(ctx, E_方向::e_横向);

	展开按钮->f_setSize({ 20,20 });
	拖动按钮->f_setSize({ 20,20 });

	f_添加子组件(展开按钮);
	f_添加子组件(拖动按钮);
	if (内部组件) {
		f_添加子组件(内部组件);
	}
	
	mf_布局 = on_展开栏布局;
}

C_展开栏::~C_展开栏() {
}

C_Widget* f_ui_创建展开框(S_UI渲染环境& ctx, C_Widget* 内部组件) {
	C_展开栏* w = new C_展开栏(ctx, 内部组件);

	w->f_setMinSize({24,24});

	return w;
}

void f_ui_展开框组件变换(C_Widget* self, mat3X2* mat, uint32 id) {
	if (id) {
		--id;
		mat->row0 = self->m_子组件[id]->m_Pos + self->m_Pos;
		mat->row1 = self->m_子组件[id]->m_Size;
	}
	else {
		mat->row0 = self->m_Pos;
		mat->row1 = self->m_Size;
	}
}

float32 f_ui_get展开组件头大小(C_Widget* self) {
	assert(dynamic_cast<C_展开栏*>(self));
	return self->m_子组件[0]->m_Size.y + self->m_间隔宽度*2;
}

S_需更新部件 f_ui_get展开组件内部组件(C_Widget* self) {
	if (self->m_子组件.size() > 2) {
		return self->m_子组件[2]->f_get更新组件();
	}
	return {};
}

//S_Props f_ui_get展开框项属性(C_Widget* self, uint32 id) {
//	if (self->m_子组件.size() > 2) {
//		return self->m_子组件[2]->m_子组件[id]->f_getProp();
//	}
//	return {};
//}


static void on_动态分列栏布局(C_Widget* self, C_Widget** w, uint32 num) {
	assert(dynamic_cast<C_动态分列栏*>(self));

	C_动态分列栏* box = (C_动态分列栏*)(self);
	
	if (box->m_排列方向 == E_方向::e_纵向) {
		float32 x = self->m_Size.x - self->m_间隔宽度 * 2;
		float32 y = self->m_间隔宽度;

		
		for (uint32 i = 0; i < num; ++i) {
			w[i]->f_setPos({ float32(self->m_间隔宽度), y });
			w[i]->f_setW(x);

			y += w[i]->m_Size.y + self->m_间隔宽度;
		}

		self->f_setH(y);

	}else{

	}
}

C_动态分列栏::C_动态分列栏(S_UI渲染环境& ctx): C_Widget(&ctx) {
	mf_布局 = on_动态分列栏布局;
	m_排列方向 = E_方向::e_纵向;
}

C_动态分列栏::~C_动态分列栏() {
}













void on_树形框项修改PropUpdate(S_Props& prop) {

}


//static void on_树形框Draw(C_Widget* self, struct S_2D画布* 画布) {
//	C_多页面* mpag = dynamic_cast<C_多页面*>(self);
//
//	mpag->m_背景绘制.m_属性 = f_vg_gen属性(画布);
//
//	S_凸边图元 图元{};
//	图元.属性 = f_vg_get属性(画布, mpag->m_背景绘制.m_属性);
//	mpag->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);
//
//	//mpag->m_背景绘制.f_Draw点(画布, mpag->m_背景绘制.m_属性, E_笔刷类型::e_条纹);
//	auto& 字体 = f_surface_get字体(*self->m_UIctx, S_UI主题::ui_默认字体);
//	mpag->m_标签绘制.f_Draw(画布, &字体, mpag->m_背景绘制.m_属性);
//
//}
//
//static void on_树形框布局(C_Widget* self, C_Widget** w, uint32 num) {
//	if (!num) return;
//
//	C_多页面* mpag = dynamic_cast<C_多页面*>(self);
//
//	vec2 pos = { 4, 4 };
//	vec2 size = mpag->m_Size;
//
//	if (mpag->m_排列方向 == E_方向::e_纵向) {
//		for (uint32 i = 1; i < num; ++i) {
//			w[i]->f_setPos(pos);
//			w[i]->f_setSize(w[i]->m_Size);
//
//			pos.y += mpag->m_头大小.y + 4;
//		}
//
//		pos = { mpag->m_头大小.x, 0 };
//		size.x -= mpag->m_头大小.x;
//
//		w[0]->f_setPos(pos);
//		w[0]->f_setSize(size);
//	}
//	else {
//		for (uint32 i = 1; i < num; ++i) {
//			w[i]->f_setPos(pos);
//			w[i]->f_setSize(w[i]->m_Size);
//
//			pos.x += mpag->m_头大小.x + 4;
//		}
//
//		pos = { 0, mpag->m_头大小.y };
//		size.y -= mpag->m_头大小.y;
//
//		w[0]->f_setPos(pos);
//		w[0]->f_setSize(size);
//	}
//
//}
//
//static void on_树形框变换修改(struct C_Widget* self) {
//	C_多页面* mpag = dynamic_cast<C_多页面*>(self);
//	uint32 标签数量 = mpag->m_分页面.size();
//	auto e = mpag->f_get更新部件();
//	uint32 num = self->f_get子部件数量();
//	return;
//
//	//mpag->m_背景绘制.f_Begin_F(标签数量 + 2);
//	mpag->m_标签绘制.f_alloc(标签数量, 10);
//
//	const auto& 字体 = f_surface_get字体库(*self->m_UIctx, S_UI主题::ui_默认字体);
//
//	mat3X2 mat;
//	if (mpag->m_排列方向 == E_方向::e_纵向) {
//		for (uint32 i = 1; i < num; ++i) {
//			mat.row0 = e.m_W[i]->m_Pos;
//			mat.row1 = e.m_W[i]->m_Size;
//			mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
//			//mpag->m_背景绘制.f_GPU参数修改(i, mat, e.m_W[i]->m_颜色A, S_Widget预设图元::m_上圆角矩形);
//
//			mpag->m_标签绘制.f_居中绘制文本({ mat.row0, mat.row1 }, S_UI主题::uic_文字颜色, i, L"mbt");
//		}
//	}
//	else {
//		mat.row0 = {};
//		mat.row1 = { self->m_Size.x, mpag->m_头大小.y };
//		mat.row2 = { S_UI主题::ui_面板圆角半径 * 2, 0 };
//		//mpag->m_背景绘制.f_GPU参数修改(0, mat, S_UI主题::uic_页面标签背景, S_Widget预设图元::m_上圆角矩形);
//
//		for (uint32 i = 1; i < num; ++i) {
//			mat.row0 = e.m_W[i]->m_Pos;
//			mat.row1 = e.m_W[i]->m_Size;
//			mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
//			//mpag->m_背景绘制.f_GPU参数修改(i, mat, e.m_W[i]->m_颜色A, S_Widget预设图元::m_上圆角矩形);
//
//			mpag->m_标签绘制.f_居中绘制文本({ mat.row0, mat.row1 }, S_UI主题::uic_文字颜色, i - 1, e.m_W[i]->m_WName);
//		}
//	}
//
//	mpag->m_背景绘制.f_setColor(mpag->m_当前页面ID + 1, e.m_W[mpag->m_当前页面ID + 1]->m_颜色C);
//
//}
//
//
//C_树形框::C_树形框(S_UI创建环境& ctx) {
//	mf_DrawFun = on_树形框Draw;
//	mf_布局Fun = on_树形框布局;
//	mf_变换修改 = on_树形框变换修改;
//}
//
//C_树形框::~C_树形框() {
//}





C_卡片框::C_卡片框(S_UI渲染环境& ctx) : C_Widget(&ctx) {

}

C_卡片框::~C_卡片框() {
}

C_Widget* f_ui_创建卡片框(S_UI渲染环境& ctx) {

	return nullptr;
}








//void C_多页面::f_创建标签(std::wstring name, int8 loc) {
//	auto e = f_get更新部件();
//	if (e.m_Num <= loc) {
//		C_Widget* 标签 = new C_Widget();
//		标签->mf_鼠标点击 = f_多页面标签选中;
//		标签->m_实例ID = 子部件数量;
//		标签->f_setSize(m_头大小);
//
//		标签->mf_鼠标进入 = on_标签鼠标进入;
//		标签->mf_鼠标离开 = on_标签鼠标移出;
//		标签->m_颜色A = S_UI主题::uic_页面标签;
//		标签->m_颜色B = S_UI主题::uic_页面标签;
//		标签->m_颜色C = S_UI主题::uic_页面焦点标签;
//		标签->m_ICO = "删除";
//		标签->m_WName = name;
//
//		if (m_可关闭) {
//			C_Widget* 关闭按钮 = new C_Widget;
//			关闭按钮->f_setSize({ 20,20 });
//			关闭按钮->m_ICO = "删除";
//			关闭按钮->mf_鼠标点击 = f_标签关闭页面;
//			标签->f_添加子组件(关闭按钮);
//		}
//
//		f_添加子组件(标签, -1);
//	}
//}
